﻿using GalaSoft.MvvmLight;
using AR.Entities;
using AR.Model;
using AR.Controls;
using AR.ViewModel;
using System.Collections.ObjectModel;
using System.Windows.Input;
using GalaSoft.MvvmLight.Command;
using System.Windows;
using AR.Models.Parametrage;
using System.Linq;
using AR.Helpers;
using System;

namespace AR.ViewModel.Parametrage
{
    /// <summary>
    /// This class contains properties that a View can data bind to.
    /// <para>
    /// See http://www.galasoft.ch/mvvm
    /// </para>
    /// </summary>
    public class GestionEntretienTechniqueViewModel : ViewModelBase
    {

        #region Attributs de la classe

        private readonly ThemeModel model;

        #region ErrorMessage
        private string _errorMessage;
        public string ErrorMessage
        {
            get
            {
                return _errorMessage;
            }
            set
            {
                if (value != _errorMessage)
                {
                    _errorMessage = value;
                    RaisePropertyChanged("ErrorMessage");
                }
            }
        }
        #endregion
        #region Theme
        private ObservableCollection<THEME> _themes;
        public ObservableCollection<THEME> Themes
        {
            get
            {
                return _themes;
            }
            set
            {
                if (value != _themes)
                {
                    _themes = value;
                    RaisePropertyChanged("Themes");
                }
            }
        }
        private string _themeIntitulee;
        public string ThemeIntitulee
        {
            get
            {
                return _themeIntitulee;
            }
            set
            {
                if (value != _themeIntitulee)
                {
                    _themeIntitulee = value;
                    RaisePropertyChanged("ThemeIntitulee");
                }
            }
        }
        private THEME _theme;
        public THEME Theme
        {
            get
            {
                return _theme;
            }
            set
            {
                if (value != _theme)
                {
                    _theme = value;
                    RaisePropertyChanged("Theme");
                    if (_theme != null)
                        ThemeIntitulee = _theme.THEME_INTITULE;
                    else
                        ThemeIntitulee = "";
                }
            }
        }
        private THEMES__TEST_TECHNIQUE _themeTest;
        public THEMES__TEST_TECHNIQUE ThemeTest
        {
            get
            {
                return _themeTest;
            }
            set
            {
                if (value != _themeTest)
                {
                    _themeTest = value;
                    RaisePropertyChanged("ThemeTest");
                }
            }
        }
        private ObservableCollection<THEME> _themeTests;
        public ObservableCollection<THEME> ThemeTests
        {
            get
            {
                return _themeTests;
            }
            set
            {
                if (value != _themeTests)
                {
                    _themeTests = value;
                    RaisePropertyChanged("ThemeTests");
                }
            }
        }
        private THEME _themeToTest;
        public THEME ThemeToTest
        {
            get
            {
                return _themeToTest;
            }
            set
            {
                if (value != _themeToTest)
                {
                    _themeToTest = value;
                    RaisePropertyChanged("ThemeToTest");
                }
            }
        }
        private ObservableCollection<THEME> _themesToTest;
        public ObservableCollection<THEME> ThemesToTest
        {
            get
            {
                return _themesToTest;
            }
            set
            {
                if (value != _themesToTest)
                {
                    _themesToTest = value;
                    RaisePropertyChanged("ThemesToTest");
                }
            }
        }

        #endregion
        #region Question
        private ObservableCollection<QUESTIONS> _Questions;
        public ObservableCollection<QUESTIONS> Questions
        {
            get
            {
                return _Questions;
            }
            set
            {
                if (value != _Questions)
                {
                    _Questions = value;
                    RaisePropertyChanged("Questions");
                }
            }
        }
        private string _questionIntitulee;
        public string QuestionIntitulee
        {
            get
            {
                return _questionIntitulee;
            }
            set
            {
                if (value != _questionIntitulee)
                {
                    _questionIntitulee = value;
                    RaisePropertyChanged("QuestionIntitulee");
                }
            }
        }
        private QUESTIONS _Question;
        public QUESTIONS Question
        {
            get
            {
                return _Question;
            }
            set
            {
                if (value != _Question)
                {
                    _Question = value;
                    RaisePropertyChanged("Question");
                    if (_Question != null)
                        QuestionIntitulee = _Question.QUESTION;
                    else
                        QuestionIntitulee = "";
                }
            }
        }
        #endregion
        #region Choix
        private ObservableCollection<CHOIX> _Choixs;
        public ObservableCollection<CHOIX> Choixs
        {
            get
            {
                return _Choixs;
            }
            set
            {
                if (value != _Choixs)
                {
                    _Choixs = value;
                    RaisePropertyChanged("Choixs");
                }
            }
        }
        private string _choixIntitulee;
        public string ChoixIntitulee
        {
            get
            {
                return _choixIntitulee;
            }
            set
            {
                if (value != _choixIntitulee)
                {
                    _choixIntitulee = value;
                    RaisePropertyChanged("ChoixIntitulee");
                }
            }
        }
        private bool _isChoixCorrect;
        public bool IsChoixCorrect
        {
            get
            {
                return _isChoixCorrect;
            }
            set
            {
                if (value != _isChoixCorrect)
                {
                    _isChoixCorrect = value;
                    RaisePropertyChanged("IsChoixCorrect");
                }
            }
        }
        private CHOIX _Choix;
        public CHOIX Choix
        {
            get
            {
                return _Choix;
            }
            set
            {
                if (value != _Choix)
                {
                    _Choix = value;
                    RaisePropertyChanged("Choix");
                    if (_Choix != null)
                    {
                        ChoixIntitulee = _Choix.CHOIX1;
                        IsChoixCorrect = _Choix.IsCorrect;
                    }
                    else
                    {
                        ChoixIntitulee = "";
                        IsChoixCorrect = false;
                    }
                }
            }
        }
        #endregion
        #region Practices
        private ObservableCollection<PRACTICE> _Practices;
        public ObservableCollection<PRACTICE> Practices
        {
            get
            {
                return _Practices;
            }
            set
            {
                if (value != _Practices)
                {
                    _Practices = value;
                    RaisePropertyChanged("Practices");
                }
            }
        }
        private string _practiceIntitulee;
        public string PracticeIntitulee
        {
            get
            {
                return _practiceIntitulee;
            }
            set
            {
                if (value != _practiceIntitulee)
                {
                    _practiceIntitulee = value;
                    RaisePropertyChanged("PracticeIntitulee");
                }
            }
        }
        private PRACTICE _Practice;
        public PRACTICE Practice
        {
            get
            {
                return _Practice;
            }
            set
            {
                if (value != _Practice)
                {
                    _Practice = value;
                    RaisePropertyChanged("Practice");
                    if (_Practice != null)
                        PracticeIntitulee = _Practice.PRACTICE1;
                    else
                        PracticeIntitulee = "";
                }
            }
        }
        #endregion
        #region TestTechnique
        private ObservableCollection<TEST_TECHNIQUE> _Tests;
        public ObservableCollection<TEST_TECHNIQUE> Tests
        {
            get
            {
                return _Tests;
            }
            set
            {
                if (value != _Tests)
                {
                    _Tests = value;
                    RaisePropertyChanged("Tests");
                }
            }
        }
        private string _testIntitulee;
        public string TestIntitulee
        {
            get
            {
                return _testIntitulee;
            }
            set
            {
                if (value != _testIntitulee)
                {
                    _testIntitulee = value;
                    RaisePropertyChanged("TestIntitulee");
                }
            }
        }
        private TEST_TECHNIQUE _Test;
        public TEST_TECHNIQUE Test
        {
            get
            {
                return _Test;
            }
            set
            {
                if (value != _Test)
                {
                    _Test = value;
                    RaisePropertyChanged("Test");
                    if (_Test != null)
                    {
                        TestIntitulee = _Test.TEST_INTITULE;
                        UpdateListeAvailableThemes(_Test);
                    }
                    else
                        TestIntitulee = "";
                }
            }
        }
        #endregion
        #region ThemeTestTechniques à vérifier si utilisé ou non !!!
        public THEMES__TEST_TECHNIQUE ThemeTestTechniques;
        #endregion
        #region Etudes
        private ObservableCollection<NIVEAU_ETUDE> _Etudes;
        public ObservableCollection<NIVEAU_ETUDE> Etudes
        {
            get
            {
                return _Etudes;
            }
            set
            {
                if (value != _Etudes)
                {
                    _Etudes = value;
                    RaisePropertyChanged("Etudes");
                }
            }
        }
        private string _etudeIntitulee;
        public string EtudeIntitulee
        {
            get
            {
                return _etudeIntitulee;
            }
            set
            {
                if (value != _etudeIntitulee)
                {
                    _etudeIntitulee = value;
                    RaisePropertyChanged("EtudeIntitulee");
                }
            }
        }
        private NIVEAU_ETUDE _Etude;
        public NIVEAU_ETUDE Etude
        {
            get
            {
                return _Etude;
            }
            set
            {
                if (value != _Etude)
                {
                    _Etude = value;
                    RaisePropertyChanged("Etude");
                    if (_Etude != null)
                        EtudeIntitulee = _Etude.INTITULE;
                    else
                        EtudeIntitulee = "";
                }
            }
        }
        #endregion
        #region Experiences
        private ObservableCollection<NIVEAU_EXPERIENCE> _Experiences;
        public ObservableCollection<NIVEAU_EXPERIENCE> Experiences
        {
            get
            {
                return _Experiences;
            }
            set
            {
                if (value != _Experiences)
                {
                    _Experiences = value;
                    RaisePropertyChanged("Experiences");
                }
            }
        }
        private string _experienceIntitulee;
        public string ExperienceIntitulee
        {
            get
            {
                return _experienceIntitulee;
            }
            set
            {
                if (value != _experienceIntitulee)
                {
                    _experienceIntitulee = value;
                    RaisePropertyChanged("ExperienceIntitulee");
                }
            }
        }
        private NIVEAU_EXPERIENCE _Experience;
        public NIVEAU_EXPERIENCE Experience
        {
            get
            {
                return _Experience;
            }
            set
            {
                if (value != _Experience)
                {
                    _Experience = value;
                    RaisePropertyChanged("Experience");
                    if (_Experience != null)
                        ExperienceIntitulee = _Experience.INTITULE;
                    else
                        ExperienceIntitulee = "";
                }
            }
        }
        #endregion
        #region Projets
        private ObservableCollection<PROJET> _Projets;
        public ObservableCollection<PROJET> Projets
        {
            get
            {
                return _Projets;
            }
            set
            {
                if (value != _Projets)
                {
                    _Projets = value;
                    RaisePropertyChanged("Projets");
                }
            }
        }
        private string _projetIntitulee;
        public string ProjetIntitulee
        {
            get
            {
                return _projetIntitulee;
            }
            set
            {
                if (value != _projetIntitulee)
                {
                    _projetIntitulee = value;
                    RaisePropertyChanged("ProjetIntitulee");
                }
            }
        }
        private PROJET _Projet;
        public PROJET Projet
        {
            get
            {
                return _Projet;
            }
            set
            {
                if (value != _Projet)
                {
                    _Projet = value;
                    RaisePropertyChanged("Practice");
                    if (_Projet != null)
                        ProjetIntitulee = _Projet.PROJET1;
                    else
                        ProjetIntitulee = "";
                }
            }
        }
        #endregion
        #region Postes
        private ObservableCollection<POSTE> _Postes;
        public ObservableCollection<POSTE> Postes
        {
            get
            {
                return _Postes;
            }
            set
            {
                if (value != _Postes)
                {
                    _Postes = value;
                    RaisePropertyChanged("Postes");
                }
            }
        }
        private string _posteIntitulee;
        public string PosteIntitulee
        {
            get
            {
                return _posteIntitulee;
            }
            set
            {
                if (value != _posteIntitulee)
                {
                    _posteIntitulee = value;
                    RaisePropertyChanged("PosteIntitulee");
                }
            }
        }
        private POSTE _Poste;
        public POSTE Poste
        {
            get
            {
                return _Poste;
            }
            set
            {
                if (value != _Poste)
                {
                    _Poste = value;
                    RaisePropertyChanged("Practice");
                    if (_Poste != null)
                        PosteIntitulee = _Poste.POST;
                    else
                        PosteIntitulee = "";
                }
            }
        }
        #endregion
        #region Candidats
        private ObservableCollection<CANDIDAT> _Candidats;
        public ObservableCollection<CANDIDAT> Candidats
        {
            get
            {
                return _Candidats;
            }
            set
            {
                if (value != _Candidats)
                {
                    _Candidats = value;
                    RaisePropertyChanged("Candidats");
                }
            }
        }
        private CANDIDAT _Candidat;
        public CANDIDAT Candidat
        {
            get
            {
                return _Candidat;
            }
            set
            {
                if (value != _Candidat)
                {
                    _Candidat = value;
                    RaisePropertyChanged("Candidat");
                }
            }
        }
        #endregion

        #endregion

        #region Constructeurs
        /// <summary>
        /// Initializes a new instance of the GestionEntretienTechniqueViewModel class.
        /// </summary>
        public GestionEntretienTechniqueViewModel()
        {
            if (WebContext.Current.User.IsAuthenticated)
            {
                if (WebContext.Current.User.IsInRole("Admin") || WebContext.Current.User.IsInRole("SolutionManager"))
                {
                    model = new ThemeModel();
                    #region Theme
                    Theme = new THEME();
                    Themes = new ObservableCollection<THEME>();
                    ThemesToTest = new ObservableCollection<THEME>();
                    model.GetThemes().EntityAdded += OnEntityThemeAdded;
                    model.GetThemes().EntityRemoved += OnEntityThemeRemoved;
                    #endregion
                    #region Question
                    Question = new QUESTIONS();
                    Questions = new ObservableCollection<QUESTIONS>();
                    model.GetQUESTIONS().EntityAdded += OnEntityQuestionsAdded;
                    model.GetQUESTIONS().EntityRemoved += OnEntityQuestionsRemoved;
                    #endregion
                    #region Choix
                    Choix = new CHOIX();
                    Choixs = new ObservableCollection<CHOIX>();
                    model.GetCHOIX().EntityAdded += OnEntityChoixsAdded;
                    model.GetCHOIX().EntityRemoved += OnEntityChoixRemoved;
                    #endregion
                    #region Practice
                    Practice = new PRACTICE();
                    Practices = new ObservableCollection<PRACTICE>();
                    model.GetPractices().EntityAdded += OnEntityPracticeAdded;
                    model.GetPractices().EntityRemoved += OnEntityPracticeRemoved;
                    #endregion
                    #region Test
                    Test = new TEST_TECHNIQUE();
                    Tests = new ObservableCollection<TEST_TECHNIQUE>();
                    model.GetTests().EntityAdded += OnEntityTestAdded;
                    model.GetTests().EntityRemoved += OnEntityTestRemoved;
                    #endregion
                    #region ThemesTest
                    ThemeTest = new THEMES__TEST_TECHNIQUE();
                    ThemeTests = new ObservableCollection<THEME>();
                    model.GetThemes().EntityAdded += OnEntityThemeTestAdded;
                    model.GetThemes().EntityRemoved += OnEntityThemeTestRemoved;
                    #endregion
                    #region Etude
                    Etude = new NIVEAU_ETUDE();
                    Etudes = new ObservableCollection<NIVEAU_ETUDE>();
                    model.GetEtudes().EntityAdded += OnEntityEtudeAdded;
                    model.GetEtudes().EntityRemoved += OnEntityEtudeRemoved;
                    #endregion
                    #region Experience
                    Experience = new NIVEAU_EXPERIENCE();
                    Experiences = new ObservableCollection<NIVEAU_EXPERIENCE>();
                    model.GetExperiences().EntityAdded += OnEntityExperienceAdded;
                    model.GetExperiences().EntityRemoved += OnEntityExperienceRemoved;
                    #endregion
                    #region Projet
                    Projet = new PROJET();
                    Projets = new ObservableCollection<PROJET>();
                    model.GetProjets().EntityAdded += OnEntityProjetAdded;
                    model.GetProjets().EntityRemoved += OnEntityProjetRemoved;
                    #endregion
                    #region Poste
                    Poste = new POSTE();
                    Postes = new ObservableCollection<POSTE>();
                    model.GetPostes().EntityAdded += OnEntityPosteAdded;
                    model.GetPostes().EntityRemoved += OnEntityPosteRemoved;
                    #endregion
                    #region Candidat
                    Candidat = new CANDIDAT();
                    Candidats = new ObservableCollection<CANDIDAT>();
                    model.GetCandidats().EntityAdded += OnEntityCandidatAdded;
                    model.GetCandidats().EntityRemoved += OnEntityCandidatRemoved;
                    #endregion
                }

                else
                {
                    NavigationService.Navigate("/ListeCandidats");
                }
            }
            else
            {
                NavigationService.Navigate("/LoginPage");
            }
        }
        #endregion                             

        #region Entities Added & Removed
        private void OnEntityThemeAdded(object sender, System.ServiceModel.DomainServices.Client.EntityCollectionChangedEventArgs<THEME> e)
        {
            if (Themes.Where(_ => _.ID_THEME == e.Entity.ID_THEME).Count() == 0)
            {
                Themes.Add(e.Entity);
                ThemesToTest.Add(e.Entity);
            }
            if (ThemeTests.Where(_ => _.ID_THEME == e.Entity.ID_THEME).Count() == 0)
            {
                ThemeTests.Add(e.Entity);
            }
        }
        private void OnEntityThemeRemoved(object sender, System.ServiceModel.DomainServices.Client.EntityCollectionChangedEventArgs<THEME> e)
        {
            if (Themes.Where(x => x.ID_THEME == e.Entity.ID_THEME && x.THEME_INTITULE == e.Entity.THEME_INTITULE).Count() != 0)
            {
                Themes.Remove(e.Entity);
                ThemesToTest.Remove(e.Entity);
            }
            if (ThemeTests.Where(x => x.ID_THEME == e.Entity.ID_THEME && x.THEME_INTITULE == e.Entity.THEME_INTITULE).Count() != 0)
            {
                ThemeTests.Remove(e.Entity);
            }
        }
        private void OnEntityThemeTestAdded(object sender, System.ServiceModel.DomainServices.Client.EntityCollectionChangedEventArgs<THEME> e)
        {
            if (ThemeTests.Where(_ => _.ID_THEME == e.Entity.ID_THEME).Count() == 0)
            {
                ThemeTests.Add(e.Entity);
                ThemesToTest.Remove(e.Entity);
            }
        }
        private void OnEntityThemeTestRemoved(object sender, System.ServiceModel.DomainServices.Client.EntityCollectionChangedEventArgs<THEME> e)
        {
            if (ThemeTests.Where(x => x.ID_THEME == e.Entity.ID_THEME && x.THEME_INTITULE == e.Entity.THEME_INTITULE).Count() != 0)
            {
                ThemeTests.Remove(e.Entity);
                ThemesToTest.Add(e.Entity);
            }
        }
        private void OnEntityQuestionsAdded(object sender, System.ServiceModel.DomainServices.Client.EntityCollectionChangedEventArgs<QUESTIONS> e)
        {
            if (Questions.Where(_ => _.ID_QUESTION == e.Entity.ID_QUESTION).Count() == 0)
                Questions.Add(e.Entity);
        }
        private void OnEntityQuestionsRemoved(object sender, System.ServiceModel.DomainServices.Client.EntityCollectionChangedEventArgs<QUESTIONS> e)
        {
            if (Questions.Where(_ => _.ID_QUESTION == e.Entity.ID_QUESTION).Count() != 0)
                Questions.Remove(e.Entity);
        }
        private void OnEntityChoixsAdded(object sender, System.ServiceModel.DomainServices.Client.EntityCollectionChangedEventArgs<CHOIX> e)
        {
            if (Choixs.Where(_ => _.IDCHOIX == e.Entity.IDCHOIX).Count() == 0)
                Choixs.Add(e.Entity);
        }
        private void OnEntityChoixRemoved(object sender, System.ServiceModel.DomainServices.Client.EntityCollectionChangedEventArgs<CHOIX> e)
        {
            if (Choixs.Where(_ => _.IDCHOIX == e.Entity.IDCHOIX).Count() != 0)
                Choixs.Remove(e.Entity);
        }
        private void OnEntityPracticeAdded(object sender, System.ServiceModel.DomainServices.Client.EntityCollectionChangedEventArgs<PRACTICE> e)
        {
            if (Practices.Where(_ => _.ID_PRACTICE == e.Entity.ID_PRACTICE).Count() == 0)
                Practices.Add(e.Entity);
        }
        private void OnEntityPracticeRemoved(object sender, System.ServiceModel.DomainServices.Client.EntityCollectionChangedEventArgs<PRACTICE> e)
        {
            if (Practices.Where(_ => _.ID_PRACTICE == e.Entity.ID_PRACTICE).Count() != 0)
                Practices.Remove(e.Entity);
        }
        private void OnEntityTestAdded(object sender, System.ServiceModel.DomainServices.Client.EntityCollectionChangedEventArgs<TEST_TECHNIQUE> e)
        {
            if (Tests.Where(_ => _.ID_TEST == e.Entity.ID_TEST).Count() == 0)
                Tests.Add(e.Entity);
        }
        private void OnEntityTestRemoved(object sender, System.ServiceModel.DomainServices.Client.EntityCollectionChangedEventArgs<TEST_TECHNIQUE> e)
        {
            if (Tests.Where(_ => _.ID_TEST == e.Entity.ID_TEST).Count() != 0)
                Tests.Remove(e.Entity);
        }
        private void OnEntityEtudeAdded(object sender, System.ServiceModel.DomainServices.Client.EntityCollectionChangedEventArgs<NIVEAU_ETUDE> e)
        {
            if (Etudes.Where(_ => _.ID_ETUDE == e.Entity.ID_ETUDE).Count() == 0)
                Etudes.Add(e.Entity);
        }
        private void OnEntityEtudeRemoved(object sender, System.ServiceModel.DomainServices.Client.EntityCollectionChangedEventArgs<NIVEAU_ETUDE> e)
        {
            if (Etudes.Where(_ => _.ID_ETUDE == e.Entity.ID_ETUDE).Count() != 0)
                Etudes.Remove(e.Entity);
        }
        private void OnEntityExperienceAdded(object sender, System.ServiceModel.DomainServices.Client.EntityCollectionChangedEventArgs<NIVEAU_EXPERIENCE> e)
        {
            if (Experiences.Where(_ => _.ID_EXPERIENCE == e.Entity.ID_EXPERIENCE).Count() == 0)
                Experiences.Add(e.Entity);
        }
        private void OnEntityExperienceRemoved(object sender, System.ServiceModel.DomainServices.Client.EntityCollectionChangedEventArgs<NIVEAU_EXPERIENCE> e)
        {
            if (Experiences.Where(_ => _.ID_EXPERIENCE == e.Entity.ID_EXPERIENCE).Count() != 0)
                Experiences.Remove(e.Entity);
        }
        private void OnEntityProjetAdded(object sender, System.ServiceModel.DomainServices.Client.EntityCollectionChangedEventArgs<PROJET> e)
        {
            if (Projets.Where(_ => _.IDPROJET == e.Entity.IDPROJET).Count() == 0)
                Projets.Add(e.Entity);
        }
        private void OnEntityProjetRemoved(object sender, System.ServiceModel.DomainServices.Client.EntityCollectionChangedEventArgs<PROJET> e)
        {
            if (Projets.Where(_ => _.IDPROJET == e.Entity.IDPROJET).Count() != 0)
                Projets.Remove(e.Entity);
        }
        private void OnEntityPosteAdded(object sender, System.ServiceModel.DomainServices.Client.EntityCollectionChangedEventArgs<POSTE> e)
        {
            if (Postes.Where(_ => _.IDPOSTE == e.Entity.IDPOSTE).Count() == 0)
                Postes.Add(e.Entity);
        }
        private void OnEntityPosteRemoved(object sender, System.ServiceModel.DomainServices.Client.EntityCollectionChangedEventArgs<POSTE> e)
        {
            if (Postes.Where(_ => _.IDPOSTE == e.Entity.IDPOSTE).Count() != 0)
                Postes.Remove(e.Entity);
        }
        private void OnEntityCandidatAdded(object sender, System.ServiceModel.DomainServices.Client.EntityCollectionChangedEventArgs<CANDIDAT> e)
        {
            if (Candidats.Where(_ => _.ID_CANDIDAT == e.Entity.ID_CANDIDAT).Count() == 0)
                Candidats.Add(e.Entity);
        }
        private void OnEntityCandidatRemoved(object sender, System.ServiceModel.DomainServices.Client.EntityCollectionChangedEventArgs<CANDIDAT> e)
        {
            if (Candidats.Where(_ => _.ID_CANDIDAT == e.Entity.ID_CANDIDAT).Count() != 0)
                Candidats.Remove(e.Entity);
        }
       
        #endregion

        #region Commands
        #region ThemeCommands
        public ICommand majThemeCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.majTheme();

                });
            }
        }
        public ICommand ajoutThemeCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.NouveauTheme();

                });
            }
        }
        public ICommand supprimeThemeCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.SuppressionTheme();

                });
            }
        }
        public void majTheme()
        {
            if (Theme != null && Theme.ID_THEME > 0)
            {
                if (!string.IsNullOrEmpty(ThemeIntitulee))
                {
                    if (Themes.Where(t => t.ID_THEME != Theme.ID_THEME && t.THEME_INTITULE.Trim().ToUpper() == ThemeIntitulee.Trim().ToUpper()).Count() == 0)
                    {
                        model.UpdateTheme(Theme.ID_THEME, ThemeIntitulee);
                        Theme = null;
                    }
                    else
                        EnvoieMsgErrLibelleUnique();
                }
                else
                    EnvoieMsgErrLibelleVide();
            }
            else
                Tools.AfficheNotificationFlash("Veuillez sélectionner le thème à modifier !");
        }
        public void NouveauTheme()
        {
            if (!string.IsNullOrEmpty(ThemeIntitulee))
            {
                if (Themes.Where(t => t.THEME_INTITULE.Trim().ToUpper() == ThemeIntitulee.Trim().ToUpper()).Count() == 0)
                {
                    model.InsertTheme(ThemeIntitulee);
                    Theme = null;
                    ThemeIntitulee = "";
                }
                else
                    EnvoieMsgErrLibelleUnique();
            }
            else
                EnvoieMsgErrLibelleVide();
        }
        public void SuppressionTheme()
        {
            if (Theme != null && Theme.ID_THEME > 0)
            {
                if (Theme.QUESTIONS.Count == 0)
                {
                    int nbTests = model.NombreTestsUtilisantTheme(Theme.ID_THEME);
                    if (nbTests == 0) //query sur tests voir avant avec taha 
                    {
                        model.RemoveTheme(Theme);
                    }
                    else
                        Tools.AfficheNotificationFlash(string.Format("Supprimer d'abord le(s) {0} test(s) utilisant ce thème !", nbTests));
                }
                else
                    Tools.AfficheNotificationFlash("Supprimer d'abord les questions de ce thème !");
            }
            else
                Tools.AfficheNotificationFlash("Veuillez sélectionner le thème à supprimer !");
        }
        #endregion
        #region QuestionCommands
        public ICommand majQuestionCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.majQuestion();

                });
            }
        }
        public ICommand ajoutQuestionCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.NouvelleQuestion();

                });
            }
        }
        public ICommand supprimeQuestionCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.SuppressionQuestion();

                });
            }
        }
        public void majQuestion()
        {
            if (Question != null && Question.ID_QUESTION > 0)
            {
                if (!string.IsNullOrEmpty(QuestionIntitulee))
                {
                    if (Questions.Where(q => q.ID_THEME == Theme.ID_THEME && q.ID_QUESTION != Question.ID_QUESTION && q.QUESTION.Trim().ToUpper() == QuestionIntitulee.Trim().ToUpper()).Count() == 0)
                    {
                        model.UpdateQuestion(Question.ID_QUESTION, QuestionIntitulee);
                        Question = null;
                    }
                    else
                        EnvoieMsgErrLibelleUnique();

                }
                else
                    EnvoieMsgErrLibelleVide();
            }
            else
                Tools.AfficheNotificationFlash("Veuillez sélectionner la question à modifier !");

        }
        public void NouvelleQuestion()
        {
            if (Theme != null && Theme.ID_THEME > 0)
            {
                if (!string.IsNullOrEmpty(QuestionIntitulee))
                {
                    if (Questions.Where(q => q.ID_THEME == Theme.ID_THEME && q.QUESTION.Trim().ToUpper() == QuestionIntitulee.Trim().ToUpper()).Count() == 0)
                    {
                        model.InsertQuestion(Theme.ID_THEME, QuestionIntitulee);
                        Question = null;
                        QuestionIntitulee = "";
                    }
                    else
                        EnvoieMsgErrLibelleUnique();
                }
                else
                    EnvoieMsgErrLibelleVide();
            }
            else
                Tools.AfficheNotificationFlash("Veuillez sélectionner le thème associé à cette question !");
        }
        private void SuppressionQuestion()
        {
            if (Question != null && Question.ID_QUESTION > 0)
            {
                if (Question.CHOIX.Count == 0)
                    model.RemoveQuestion(Question);
                else
                    Tools.AfficheNotificationFlash("Supprimer d'abord les choix de cette question !");
            }
            else
                Tools.AfficheNotificationFlash("Veuillez sélectionner la question à supprimer !");
        }
        #endregion
        #region ChoixCommands
        public ICommand majChoixCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.MajChoix();

                });
            }
        }
        public ICommand ajoutChoixCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.NouveauChoix();

                });
            }
        }
        public ICommand supprimeChoixCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.SuppressionChoix();

                });
            }
        }
        public void MajChoix()
        {
            if (Choix != null && Choix.IDCHOIX > 0)
            {
                if (!string.IsNullOrEmpty(ChoixIntitulee) && IsChoixCorrect != null)
                {
                    if (Choixs.Where(s => s.ID_QUESTION == Question.ID_QUESTION && s.IDCHOIX != Choix.IDCHOIX && s.CHOIX1.Trim().ToUpper() == ChoixIntitulee.Trim().ToUpper()).Count() == 0)
                    {
                        model.UpdateChoix(Choix.IDCHOIX, ChoixIntitulee, IsChoixCorrect);
                        Choix = null;
                    }
                    else
                        EnvoieMsgErrLibelleUnique();
                }
                else
                    EnvoieMsgErrLibelleVide();
            }
            else
                Tools.AfficheNotificationFlash("Veuillez sélectionner le choix à modifier !");

        }
        public void NouveauChoix()
        {
            if (Question != null && Question.ID_QUESTION > 0)
            {
                if (!string.IsNullOrEmpty(ChoixIntitulee))
                {
                    if (Choixs.Where(s => s.ID_QUESTION == Question.ID_QUESTION && s.CHOIX1.Trim().ToUpper() == ChoixIntitulee.Trim().ToUpper()).Count() == 0)
                    {
                        model.InsertChoix(ChoixIntitulee, IsChoixCorrect, Question.ID_QUESTION);
                        Choix = null;
                        ChoixIntitulee = "";
                    }
                    else
                        EnvoieMsgErrLibelleUnique();
                }
                else
                    EnvoieMsgErrLibelleVide();
            }
            else
                Tools.AfficheNotificationFlash("Veuillez sélectionner la question associée à ce choix !");
        }
        public void SuppressionChoix()
        {
            if (Choix != null && Choix.IDCHOIX > 0)
                model.RemoveChoix(Choix);
            else
                Tools.AfficheNotificationFlash("Veuillez sélectionner le choix à supprimer !");

        }
        #endregion
        #region PracticeCommands
        public ICommand majPracticeCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.MajPractice();

                });
            }
        }
        public ICommand ajoutPracticeCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.NouveauPractice();

                });
            }
        }
        public ICommand supprimePracticeCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.SuppressionPractice();

                });
            }
        }
        public void MajPractice()
        {
            if (Practice != null && Practice.ID_PRACTICE > 0)
            {
                if (!string.IsNullOrEmpty(PracticeIntitulee))
                {
                    if (Practices.Where(p => p.ID_PRACTICE != Practice.ID_PRACTICE && p.PRACTICE1.Trim().ToUpper() == PracticeIntitulee.Trim().ToUpper()).Count() == 0)
                    {
                        model.UpdatePractice(Practice.ID_PRACTICE, PracticeIntitulee);
                        Practice = null;
                    }
                    else
                        EnvoieMsgErrLibelleUnique();
                }
                else
                    EnvoieMsgErrLibelleVide();
            }
            else
                Tools.AfficheNotificationFlash("Veuillez sélectionner la practice à modifier !");

        }
        public void NouveauPractice()
        {
            if (!string.IsNullOrEmpty(PracticeIntitulee))
            {
                if (Practices.Where(p => p.PRACTICE1.Trim().ToUpper() == PracticeIntitulee.Trim().ToUpper()).Count() == 0)
                {
                    model.InsertPractice(PracticeIntitulee);
                    Practice = null;
                    PracticeIntitulee = "";
                }
                else
                    EnvoieMsgErrLibelleUnique();
            }
            else
                EnvoieMsgErrLibelleVide();
        }
        public void SuppressionPractice()
        {
            if (Practice != null && Practice.ID_PRACTICE > 0)
            {
                int nbTests = model.NombreTestsUtilisantPractice(Practice.ID_PRACTICE);
                if (nbTests == 0) //query sur tests voir avant avec taha 
                {
                    int nbCandidats = Candidats.Where(c => c.ID_PRACTICE == Practice.ID_PRACTICE).Count();
                    if (nbCandidats == 0) //query sur tests voir avant avec taha 
                    {
                        model.RemovePractice(Practice);
                    }
                    else
                        Tools.AfficheNotificationFlash(string.Format("Il y a {0} candidat(s) utilisant cette practice !", nbCandidats));
                }
                else
                    Tools.AfficheNotificationFlash(string.Format("Supprimer d'abord le(s) {0} test(s) utilisant cette practice !", nbTests));
            }
            else
                Tools.AfficheNotificationFlash("Veuillez sélectionner la practice à supprimer !");

        }
        #endregion
        #region TestCommands
        public ICommand majTestCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.MajTest();

                });
            }
        }
        public ICommand ajoutTestCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.NouveauTest();

                });
            }
        }
        public ICommand supprimeTestCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.SuppressionTest();

                });
            }
        }
        public void MajTest()
        {
            if (Test != null && Test.ID_TEST > 0)
            {
                if (!string.IsNullOrEmpty(TestIntitulee))
                {
                    if (Tests.Where(t => t.ID_TEST != Test.ID_TEST && t.TEST_INTITULE.Trim().ToUpper() == TestIntitulee.Trim().ToUpper()).Count() == 0)
                    {
                        model.UpdateTest(Test.ID_TEST, TestIntitulee);
                        Test = null;
                    }
                    else
                        EnvoieMsgErrLibelleUnique();
                }
                else
                    EnvoieMsgErrLibelleVide();
            }
            else
                Tools.AfficheNotificationFlash("Veuillez sélectionner le test à modifier !");

        }
        public void NouveauTest()
        {

            if (Practice != null && Practice.ID_PRACTICE > 0)
            {
                if (!string.IsNullOrEmpty(TestIntitulee))
                {
                    if (Tests.Where(t => t.TEST_INTITULE.Trim().ToUpper() == TestIntitulee.Trim().ToUpper()).Count() == 0)
                    {
                        model.InsertTest(Practice.ID_PRACTICE, TestIntitulee);
                        Test = null;
                        TestIntitulee = "";
                    }
                    else
                        EnvoieMsgErrLibelleUnique();
                }
                else
                    EnvoieMsgErrLibelleVide();
            }
            else
                Tools.AfficheNotificationFlash("Veuillez sélectionner la practice associée à ce test !");


        }
        public void SuppressionTest()
        {
            if (Test != null && Test.ID_TEST > 0)
            {
                if (Test.THEMES__TEST_TECHNIQUE.Count() == 0)
                {
                    if (Test.CANDIDAT.Count() == 0)
                        model.RemoveTest(Test);
                    else
                        Tools.AfficheNotificationFlash("Assurez-vous d'abord qu'il n'y a pas de candidat utilisant ce test!");
                }
                else
                    Tools.AfficheNotificationFlash("Assurez-vous d'abord que ce test ne contient aucun thème !");
            }
            else
                Tools.AfficheNotificationFlash("Veuillez sélectionner le test à supprimer !");
        }
        #endregion
        #region ThemeTestCommands
        public ICommand ajoutThemeTestCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.AjoutThemeTest();

                });
            }
        }
        public ICommand supprimeThemeTestCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.SuppressionThemeTest();

                });
            }
        }
        public void AjoutThemeTest()
        {
            if (Test != null && Test.ID_TEST > 0 && ThemeToTest != null && ThemeToTest.ID_THEME > 0)
            {
                int nb = Test.THEMES__TEST_TECHNIQUE.Where(x => x.ID_THEME == ThemeToTest.ID_THEME).Count();
                if (nb == 0)
                {
                    model.AjoutThemeTest(Test.ID_TEST, ThemeToTest.ID_THEME);
                    ThemesToTest.Remove(ThemeToTest);
                }
                else
                    Tools.AfficheNotificationFlash("Ce thème existe déjà !");
            }
            else
                Tools.AfficheNotificationFlash("Veuillez sélectionner le test à modifier !");

        }
        public void SuppressionThemeTest()
        {
            try
            {
                if (ThemeTest != null && ThemeTest.ID_THEME > 0 && Test != null && Test.ID_TEST > 0)
                {
                    model.SupressionThemeTest(ThemeTest.ID_TEST, ThemeTest.ID_THEME);
                    ThemesToTest.Add(ThemeTest.THEME);
                }
                else
                    Tools.AfficheNotificationFlash("Veuillez sélectionner le thème à enlever !");
            }
            catch (System.Exception ex)
            {
                ErrorMessage = ex.StackTrace;
            }

        }
        #endregion
        #region EtudeCommands
        public ICommand majEtudeCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.MajEtude();

                });
            }
        }
        public ICommand ajoutEtudeCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.NouveauEtude();

                });
            }
        }
        public ICommand supprimeEtudeCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.SuppressionEtude();

                });
            }
        }
        public void MajEtude()
        {
            if (Etude != null && Etude.ID_ETUDE > 0)
            {
                if (!string.IsNullOrEmpty(EtudeIntitulee))
                {
                    if (Etudes.Where(e => e.ID_ETUDE != Etude.ID_ETUDE && e.INTITULE.Trim().ToUpper() == EtudeIntitulee.Trim().ToUpper()).Count() == 0)
                    {
                        model.UpdateEtude(Etude.ID_ETUDE, EtudeIntitulee);
                        Etude = null;
                    }
                    else
                        EnvoieMsgErrLibelleUnique();
                }
                else
                    EnvoieMsgErrLibelleVide();
            }
            else
                Tools.AfficheNotificationFlash("Veuillez sélectionner le niveau d'étude à modifier !");

        }
        public void NouveauEtude()
        {
            if (!string.IsNullOrEmpty(EtudeIntitulee))
            {
                if (Etudes.Where(e => e.INTITULE.Trim().ToUpper() == EtudeIntitulee.Trim().ToUpper()).Count() == 0)
                {
                    model.InsertEtude(EtudeIntitulee);
                    Etude = null;
                    EtudeIntitulee = "";
                }
                else
                    EnvoieMsgErrLibelleUnique();
            }
            else
                EnvoieMsgErrLibelleVide();
        }
        public void SuppressionEtude()
        {
            if (Etude != null && Etude.ID_ETUDE > 0)
            {
                int nbCandidats = Candidats.Where(c => c.ID_ETUDE == Etude.ID_ETUDE).Count();
                if (nbCandidats == 0)
                    model.RemoveEtude(Etude);
                else
                    Tools.AfficheNotificationFlash(string.Format("Il y a {0} candidat(s) utilisant ce niveau d'étude !", nbCandidats));
            }
            else
                Tools.AfficheNotificationFlash("Veuillez sélectionner le niveau d'étude à supprimer !");

        }
        #endregion
        #region ExperienceCommands
        public ICommand majExperienceCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.MajExperience();

                });
            }
        }
        public ICommand ajoutExperienceCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.NouveauExperience();

                });
            }
        }
        public ICommand supprimeExperienceCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.SuppressionExperience();

                });
            }
        }
        public void MajExperience()
        {
            if (Experience != null && Experience.ID_EXPERIENCE > 0)
            {
                if (!string.IsNullOrEmpty(ExperienceIntitulee))
                {
                    if (Experiences.Where(e => e.ID_EXPERIENCE != Experience.ID_EXPERIENCE && e.INTITULE.Trim().ToUpper() == ExperienceIntitulee.Trim().ToUpper()).Count() == 0)
                    {
                        model.UpdateExperience(Experience.ID_EXPERIENCE, ExperienceIntitulee);
                        Experience = null;
                    }
                    else
                        EnvoieMsgErrLibelleUnique();
                }
                else
                    EnvoieMsgErrLibelleVide();
            }
            else
                Tools.AfficheNotificationFlash("Veuillez sélectionner le niveau d'expérience à modifier !");

        }
        public void NouveauExperience()
        {
            if (!string.IsNullOrEmpty(ExperienceIntitulee))
            {
                if (Experiences.Where(e => e.INTITULE.Trim().ToUpper() == ExperienceIntitulee.Trim().ToUpper()).Count() == 0)
                {
                    model.InsertExperience(ExperienceIntitulee);
                    Experience = null;
                    ExperienceIntitulee = "";
                }
                else
                    EnvoieMsgErrLibelleUnique();
            }
            else
                EnvoieMsgErrLibelleVide();
        }
        public void SuppressionExperience()
        {
            if (Experience != null && Experience.ID_EXPERIENCE > 0)
            {
                int nbCandidats = Candidats.Where(c => c.ID_EXPERIENCE == Experience.ID_EXPERIENCE).Count();
                if (nbCandidats == 0)
                    model.RemoveExperience(Experience);
                else
                    Tools.AfficheNotificationFlash(string.Format("Il y a {0} candidat(s) utilisant ce niveau d'expérience !", nbCandidats));
            }
            else
                Tools.AfficheNotificationFlash("Veuillez sélectionner le niveau d'expérience à supprimer !");

        }
        #endregion
        #region ProjetCommands
        public ICommand majProjetCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.MajProjet();

                });
            }
        }
        public ICommand ajoutProjetCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.NouveauProjet();

                });
            }
        }
        public ICommand supprimeProjetCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.SuppressionProjet();

                });
            }
        }
        public void MajProjet()
        {
            if (Projet != null && Projet.IDPROJET > 0)
            {
                if (!string.IsNullOrEmpty(ProjetIntitulee))
                {
                    if (Projets.Where(p => p.IDPROJET != Projet.IDPROJET && p.PROJET1.Trim().ToUpper() == ProjetIntitulee.Trim().ToUpper()).Count() == 0)
                    {
                        model.UpdateProjet(Projet.IDPROJET, ProjetIntitulee);
                        Projet = null;
                        ProjetIntitulee = "";
                    }
                    else
                        EnvoieMsgErrLibelleUnique();
                }
                else
                    EnvoieMsgErrLibelleVide();
            }
            else
                Tools.AfficheNotificationFlash("Veuillez sélectionner le projet à modifier !");

        }
        public void NouveauProjet()
        {
            if (!string.IsNullOrEmpty(ProjetIntitulee))
            {
                if (Projets.Where(p => p.PROJET1.Trim().ToUpper() == ProjetIntitulee.Trim().ToUpper()).Count() == 0)
                {
                    model.InsertProjet(ProjetIntitulee);
                    Projet = null;
                    ProjetIntitulee = "";
                }
                else
                    EnvoieMsgErrLibelleUnique();
            }
            else
                EnvoieMsgErrLibelleVide();
        }
        public void SuppressionProjet()
        {
            if (Projet != null && Projet.IDPROJET > 0)
            {
                int nbCandidats = Candidats.Where(c => c.ID_PROJET == Projet.IDPROJET).Count();
                if (nbCandidats == 0)
                    model.RemoveProjet(Projet);
                else
                    Tools.AfficheNotificationFlash(string.Format("Il y a {0} candidat(s) utilisant ce projet !", nbCandidats));
            }
            else
                Tools.AfficheNotificationFlash("Veuillez sélectionner le projet à supprimer !");

        }
        #endregion
        #region PosteCommands
        public ICommand majPosteCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.MajPoste();

                });
            }
        }
        public ICommand ajoutPosteCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.NouveauPoste();

                });
            }
        }
        public ICommand supprimePosteCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    this.SuppressionPoste();

                });
            }
        }
        public void MajPoste()
        {
            if (Poste != null && Poste.IDPOSTE > 0)
            {
                if (!string.IsNullOrEmpty(PosteIntitulee))
                {
                    if (Postes.Where(p => p.IDPOSTE != Poste.IDPOSTE && p.POST.Trim().ToUpper() == PosteIntitulee.Trim().ToUpper()).Count() == 0)
                    {
                        model.UpdatePoste(Poste.IDPOSTE, PosteIntitulee);
                        Poste = null;
                    }
                    else
                        EnvoieMsgErrLibelleUnique();
                }
                else
                    EnvoieMsgErrLibelleVide();
            }
            else
                Tools.AfficheNotificationFlash("Veuillez sélectionner le poste à modifier !");

        }
        public void NouveauPoste()
        {
            if (!string.IsNullOrEmpty(PosteIntitulee))
            {
                if (Postes.Where(p => p.POST.Trim().ToUpper() == PosteIntitulee.Trim().ToUpper()).Count() == 0)
                {
                    model.InsertPoste(PosteIntitulee);
                    Poste = null;
                    PosteIntitulee = "";
                }
                else
                    EnvoieMsgErrLibelleUnique();
            }
            else
                EnvoieMsgErrLibelleVide();
        }
        public void SuppressionPoste()
        {
            if (Poste != null && Poste.IDPOSTE > 0)
            {
                int nbCandidats = Candidats.Where(c => c.ID_POSTE == Poste.IDPOSTE).Count();
                if (nbCandidats == 0)
                    model.RemovePoste(Poste);
                else
                    Tools.AfficheNotificationFlash(string.Format("Il y a {0} candidat(s) utilisant ce poste !", nbCandidats));
            }
            else
                Tools.AfficheNotificationFlash("Veuillez sélectionner la practice à supprimer !");

        }
        #endregion 
        #endregion


        #region Fonctions internes
        private void UpdateListeAvailableThemes(TEST_TECHNIQUE test)
        {
            foreach (THEME item in Themes)
            {
                if (!ThemesToTest.Contains(item))
                    ThemesToTest.Add(item);
            }
            if (test != null)
            {
                foreach (THEMES__TEST_TECHNIQUE item in test.THEMES__TEST_TECHNIQUE)
                {
                    if (ThemesToTest.Contains(item.THEME))
                        ThemesToTest.Remove(item.THEME);
                }
            }


        } 
        #endregion
       
        #region MessagesBox
        private void EnvoieMsgErrLibelleVide()
        {
            Tools.AfficheNotificationFlash("Veuillez écrire un libellé valide !");
        }
        private void EnvoieMsgErrLibelleUnique()
        {
            Tools.AfficheNotificationFlash("Ce libellé existe déjà dans la liste !",2);
        } 

        #endregion
    }
}